package com.kj.tms.system.service.menu.serviceImpl;


import com.kj.tms.common.bean.dao.BaseMapper;
import com.kj.tms.common.bean.dto.Pager;
import com.kj.tms.common.bean.dto.ReturnData;
import com.kj.tms.common.bean.dto.TreeCheck;
import com.kj.tms.common.bean.dto.TreeData;
import com.kj.tms.common.bean.exception.BusinessException;
import com.kj.tms.common.bean.redis.RedisAccess;
import com.kj.tms.common.bean.service.BaseService;
import com.kj.tms.common.utils.StringUtil;
import com.kj.tms.common.utils.constant.Consts;
import com.kj.tms.common.utils.uuid.IdGen;
import com.kj.tms.pri.system.menu.dto.DictDto;
import com.kj.tms.pri.system.menu.service.DictService;
import com.kj.tms.system.service.menu.dao.DictMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.*;

/**
 * <p>项目名称：system<p>
 * <p>类名称：DictServiceImpl<p>
 * <p>类描述：字典表业务实现类<p>
 *
 * @author 创建人：yangruidong
 * @author 创建时间： 2017年10月18日 9:41
 * @author 修改人：yangruidong
 * @author 修改时间：2017年10月18日 9:41
 * @author 修改备注：
 * @version: 2017年10月18日
 */
@RestController
public class DictServiceImpl extends BaseService<DictDto> implements DictService {

    private static final Logger logger = LoggerFactory.getLogger(DictServiceImpl.class);

    @Resource
    private DictMapper dictMapper;
    @Autowired
    private RedisAccess redisAccessImpl;

    @Override
    public BaseMapper<DictDto> getMapper() {
        return dictMapper;
    }

    /**
     * 分页查询
     *
     * @param model
     * @return
     */
    @Override
    public Pager queryByPage(@RequestBody DictDto model) {
        return super.selectPage(model);
    }

    @Override
    public DictDto queryTdPeriod(@RequestBody Map map) {
        return dictMapper.queryTdPeriod(map);
    }

    @Override
    public List<DictDto> listTdPeriod(@RequestBody Map map) {
        return dictMapper.listTdPeriod(map);
    }

    @Override
    public List<DictDto> listByTaxCode(@RequestParam("taxCode") String taxCode, @RequestParam("tdperdCode") String tdperdCode) {
        return dictMapper.listByTaxCode(taxCode,tdperdCode);
    }

    @Override
    public List<DictDto> listByCondition(@RequestBody DictDto dto) {
        return dictMapper.listByCondition(dto);
    }

    @Override
    public List<DictDto> queryByList(@RequestBody DictDto dto) {
        return dictMapper.queryByList(dto);
    }

    @Override
    public List<DictDto> listByTaxDentufy(@RequestBody Map map) throws Exception {
        return dictMapper.listByTaxDentufy(map);
    }

    /**
     * @param dictDto
     * @return Map
     * @Title:getTree
     * @Description：获取模块树加载数据
     */
    public ReturnData getTree(@RequestBody DictDto dictDto) {
        Map<String, Object> returnMap = new HashMap<String, Object>();
        List<DictDto> allXtmkInfos = new ArrayList<>();
        try {
            DictDto model = new DictDto();
            // 获取模块
            model.setDelMark(Consts.DEL_MARK_0);
            allXtmkInfos = dictMapper.listByCondition(dictDto);
        } catch (Exception e) {
            logger.error(e.getMessage());
            throw new BusinessException(Consts.ERROR, "获取树形失败", "");
        }
        List<TreeCheck> treeRoleModules = new ArrayList<>();
        for (DictDto dto : allXtmkInfos) {
            TreeCheck treeRoleModule = new TreeCheck();
            treeRoleModule.setId(dto.getDictId());
            treeRoleModule.setpId(dto.getParentDictId());
            treeRoleModule.setName(dto.getDictName());
            treeRoleModule.setOpen(false);
            treeRoleModules.add(treeRoleModule);
        }
        TreeCheck treeRoleModule1 = new TreeCheck();
        treeRoleModule1.setId("0");
        treeRoleModule1.setpId("-1");
        treeRoleModule1.setName("字典信息");
        treeRoleModules.add(treeRoleModule1);
        returnMap.put("data", treeRoleModules);
        returnMap.put("date", new Date());
        return new ReturnData(Consts.SUCCESS, "获取成功", returnMap);
    }

    /**
     * @param dictDto
     * @return
     * @throws
     * @method [save]
     * @description [添加]
     * @author 王国庆
     * @version 1.0
     * @date 2017年11月09日 15:22
     */
    public ReturnData save(@RequestBody DictDto dictDto) {
        dictDto.setDictId(IdGen.getId());
        try {
            dictMapper.save(dictDto);
        } catch (Exception e) {
            logger.error(e.getMessage());
            throw new BusinessException(Consts.ERROR, "保存失败", "");
        }
        //保存、修改之后，更新redis 放入字典列表
        updateRedisData(dictDto,"save");
        return new ReturnData(Consts.SUCCESS, "保存成功", null);
    }

    /**
     * 修改数据 注意修改上级数据下级数据一起修改
     *
     * @param dto
     */
    @Override
    public ReturnData updateData(@RequestBody DictDto dto) {
        DictDto paraDto = new DictDto();
        paraDto.setParentDictId(dto.getDictId());
        try {
            //修改父节点
            dictMapper.update(dto);
            //修改子节点dictType
            paraDto.setDictType(dto.getDictCode());
            dictMapper.update(paraDto);
        } catch (Exception e) {
            logger.error(e.getMessage());
            throw new BusinessException(Consts.ERROR, "保存失败", "");
        }
        //保存、修改之后，更新redis 放入字典列表
        updateRedisData(dto,"update");
        return new ReturnData(Consts.SUCCESS, "保存成功", null);
    }

    /**
     * 删除数据 注意删除上级数据下级数据一起删除
     *
     * @param dto
     */
    @Override
    public ReturnData deleteData(@RequestBody DictDto dto) {
        DictDto paraDto = new DictDto();
        paraDto.setParentDictId(dto.getDictId());
        try {
            //删除父节点
            dictMapper.delete(dto);
            //删除子节点
            dictMapper.delete(paraDto);
        } catch (Exception e) {
            logger.error(e.getMessage());
            throw new BusinessException(Consts.ERROR, "删除失败", "");
        }
        //保存、修改、删除或者禁用启用之后，更新redis 放入字典列表
        deleteRedisData(dto);
        return new ReturnData(Consts.SUCCESS, "删除成功", null);
    }

    /**
     * @param dto
     * @return List<DictDto>
     * @throws
     * @method [queryByList]
     * @description [条件查询全部信息]
     * @author 王国庆
     * @version 1.0
     * @date 2017年11月09日 14:26
     */
    @Override
    public List<DictDto> listByDictDto(@RequestBody DictDto dto) {
        return dictMapper.queryByList(dto);
    }

    /**
     * @param dictDto
     * @return DictDto对象
     * @throws
     * @method [getByCondition]
     * @description [查询返回单个dto]
     * @author 王国庆
     * @version 1.0
     * @date 2017年11月09日 15:19
     */
    public DictDto getByCondition(@RequestBody DictDto dictDto) {
        return dictMapper.getByCondition(dictDto);
    }


    /**
     * @param dictType
     * @return List<DictDto>
     * @throws
     * @method listByDictType
     * @description 根据类型获取字典list
     * @author 董世栋
     * @version 1.0
     * @date
     */
    @Override
    public List<DictDto> listByDictType(@RequestParam("dictType")String dictType) {
        DictDto model = new DictDto();
        model.setDelMark(Consts.DEL_MARK_0);
        model.setDictType(dictType);
        List<DictDto> listDict = this.listByDictDto(model);;
        return listDict;
    }

    /**
     * @param regType,incomeScale,taxpayerQualification,vatLimit
     * @return Map
     * @throws
     * @method queryTaxPayerByDictType
     * @description 根据类型获取字典Map（纳税主体使用）
     * @author 董世栋
     * @version 1.0
     * @date
     */
    @Override
    public Map<String, Object> listByDictTypeS(@RequestParam("regType") String regType,
                                               @RequestParam("incomeScale") String incomeScale,
                                               @RequestParam("taxpayerQualification") String taxpayerQualification,
                                               @RequestParam("vatLimit") String vatLimit) {
        Map<String, Object> map = new HashMap<>(); 
        //注册类型
        List<DictDto> regTypeList = listByDictType(regType);
        //收入规模
        List<DictDto> incomeScaleList = listByDictType(incomeScale);
        //增值税纳税人类型
        List<DictDto> taxpayerQualificationList = listByDictType(taxpayerQualification);
        //增值税专用发票最高限额
        List<DictDto> vatLimitList = listByDictType(vatLimit);

        map.put("regTypeList", regTypeList);
        map.put("incomeScaleList", incomeScaleList);
        map.put("taxpayerQualificationList", taxpayerQualificationList);
        map.put("vatLimitList", vatLimitList);
        return map;
    }

    /**
     * @method      [listByConditionMap]
     * @description [根据申报税种查询申报周期]
     * @author      [yangruidong]
     * @version     1.0
     * @param
     * @return
     * @exception
     * @date
     */
    @Override
    public List<DictDto> listByConditionMap(@RequestBody Map map) {
        return dictMapper.listByConditionMap(map);
    }

    /**
     * @return void
     * @method [updateRedisData]
     * @description [字典模块 保存、修改之后，更新redis]
     * @author 王国庆
     * @param  dictDto
     * @param  type   save 为新增类型  update 为修改类型
     * @version 1.0
     * @date 2017年11月09日 10:04
     */
    private void updateRedisData(DictDto dictDto,String type) {
        //判断是否属于上层编码
        String dictType= dictDto.getDictType();
        
        
        List<DictDto> dictList =  redisAccessImpl.hget(Consts.DICT,dictType);
        
        if("save".equals(type)){
            if(!StringUtil.isEmptyOrNull(dictList)) {
                dictList.add(dictDto);
            }else{
                dictList = new ArrayList<>();
                dictList.add(dictDto);
            }
            redisAccessImpl.hset(Consts.DICT, dictType, dictList, -1);
            return;
        }
        if(!StringUtil.isEmptyOrNull(dictList)) {
            
            for (int k = 0; k < dictList.size(); k++) {
                if (dictDto.getDictCode().equals(dictList.get(k).getDictCode())) {
                    dictList.get(k).setDictName(dictDto.getDictName());
                    redisAccessImpl.hset(Consts.DICT, dictType, dictList, -1);
                    break;
                }
            }
        }
    
    }

    /**

     * @method [deleteRedisData]
     * @description [字典模块 删除之后，更新redis]
     * @author 王国庆
     * @param  dictDto
     * @return void
     * @version 1.0
     * @date 2017年11月09日 10:04
     */
    private void deleteRedisData(DictDto dictDto) {
        String dictType= dictDto.getDictType();
        List<DictDto> dictList =  redisAccessImpl.hget(Consts.DICT,dictType);
        if(!StringUtil.isEmptyOrNull(dictList)) {
            for (int k = 0; k < dictList.size(); k++) {
                if (dictDto.getDictCode().equals(dictList.get(k).getDictCode())) {
                    dictList.remove(dictList.get(k));
                    redisAccessImpl.hset(Consts.DICT, dictType, dictList, -1);
                    break;
                }
            }
        }
    }


    /**
     * @method      [listTreeDataByDictType]
     * @description [根据类型查询字典树]
     * @author      王国庆
     * @version     1.0
     * @param        dictType 字典类型
     * @return
     * @exception
     * @date        2018年03月23日 14:34
     */
    public List<TreeData> listTreeDataByDictType(@RequestParam("dictType") String dictType){
        return dictMapper.listTreeDataByDictType(dictType);
    }
}
